home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / demo / igps_102.zip / PHONEVW.CPP < prev    next >
C/C++ Source or Header  |  1994-12-01  |  40KB  |  1,195 lines
  1. ///////////////////////////////////////////////////////////////////////////////////
  2. // Internet Global Phone Project
  3. // CPhoneView  phonevw.cpp : implementation of the CPhoneView class
  4. //
  5. // The Phoneview class is responsible for user interface handling and low level 
  6. // audio handling (including compression/decompression via GSM).
  7. //
  8. ////////////////////////////////////////////////////////////////////////////////////
  9. // Copyright (c) 1993-1994    microWonders Inc.  All rights reserved.
  10. //                                                                         
  11. // AN OPEN INVITION TO BUILD UPON AND CONTRIBUTE TO THE PUBLIC TECHNOLOGY POOL:
  12. // You are encouraged to redistribute, and build upon the technologies presented 
  13. // in this source module and the accompanying article in Dr. Dobb's Journal provided 
  14. // all the conditions listed in the MUSTREAD.TXT file, included with this 
  15. // distribution, are met.
  16. ////////////////////////////////////////////////////////////////////////////////////
  17. // Full DUPLEX is not possible currently due to drivers restriction, either sound 
  18. // rec or play only
  19. //
  20. // June 11,1994  Eliminate lock-step transmit-receive requirement
  21. // June 10,1994     Added fool-proof checks on button states to avoid
  22. //                 crashes due to multiple button presses (SL)
  23. // June 5, 1994  fixed occasional buffer drop out due to OnRecordDone resetting
  24. //               some variables incorrectly (SL)  
  25. // June 2, 1994  fixed playback always at length - sizeof(GSM_FRAME) problem (SL)
  26. // May 20, 1994  separated OLE2 dependencies, no longer needs OLE DLLs (SL)
  27. // May 10, 1994  added 16 bit sound support via #define HI_FIDELITY switch(SL)
  28. // 
  29. //===================================================================================
  30. //
  31. //    UMIST distribution Revisions
  32. //
  33. // Nov 30, 1994        changed sampling frequency to 11025hz (PA)
  34. //                    fixed bug that crashed program if it finished compressing
  35. //                    first block while second was still recording. (PA)
  36.  
  37.  
  38.  
  39. #include "stdafx.h" 
  40. #include "mmsystem.h"
  41. #include "mphone.h"
  42.  
  43. #include "phonedoc.h"  
  44. #include "wsmin.h" 
  45. #include "socket.h"
  46. #include "talksock.h"
  47. #include "phonevw.h"
  48. #include "gsm.h" 
  49.  
  50. #include "dlg_host.h"
  51. #ifdef _DEBUG
  52. #undef THIS_FILE
  53. static char BASED_CODE THIS_FILE[] = __FILE__;
  54. #endif
  55.  
  56. IMPLEMENT_DYNCREATE(CPhoneView, CEditView)
  57.  
  58. BEGIN_MESSAGE_MAP(CPhoneView, CEditView)
  59.     //{{AFX_MSG_MAP(CPhoneView)   
  60.       ON_MESSAGE(MM_WIM_CLOSE, OnWaveInClose)
  61.         ON_MESSAGE(MM_WIM_OPEN, OnWaveInOpen)      
  62.         ON_MESSAGE(MM_WIM_DATA, OnWaveInData)
  63.         ON_MESSAGE(MM_WOM_DONE, OnWaveOutDone) 
  64.       ON_MESSAGE(PHONEMSG_RECORD_DONE, OnRecordDone)
  65.       ON_MESSAGE(PHONEMSG_COMPRESS_DONE, OnCompressDone)
  66.       ON_MESSAGE(WM_WSANOTIFY, OnClientNotify)
  67.       ON_UPDATE_COMMAND_UI(ID_PHONE_RECORD, OnUpdatePhRecord)
  68.       ON_UPDATE_COMMAND_UI(ID_PHONE_SEND, OnUpdatePhSend)
  69.       ON_COMMAND(ID_PHONE_RECORD, OnPhRecord)
  70.       ON_COMMAND(ID_PHONE_SEND, OnPhSend)
  71.       ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
  72.     //}}AFX_MSG_MAP
  73. END_MESSAGE_MAP()
  74.  
  75. /////////////////////////////////////////////////////////////////////////////
  76. // CPhoneView construction/destruction
  77.  
  78. CPhoneView::CPhoneView()
  79. {
  80.     // TODO: add construction code here   
  81.     m_recording = FALSE;
  82.     m_transmitting = FALSE;
  83.     m_hWaveIn = 0;           
  84.     m_hWaveOut = 0;
  85.     if (!(m_hGsm = gsm_create()))
  86.     {       
  87.      AfxGetMainWnd()->MessageBox("Cannot initialize gsm?");
  88.      return;
  89.     }              
  90.     // set up compression buffer
  91.     m_CompBufSize = 0L;
  92.     m_hCompress = GlobalAlloc(GHND , (DWORD) COMPRESSED_BUFSIZE);
  93.     if (!m_hCompress)
  94.     {
  95.       AfxGetMainWnd()->MessageBox("cannot allocate compress buffer!");
  96.       return;
  97.     }             
  98.     m_CompressedBuf = (HPSTR) GlobalLock(m_hCompress);
  99.     if (!m_CompressedBuf)
  100.     {
  101.       GlobalUnlock(m_hCompress);
  102.       GlobalFree(m_hCompress);
  103.       AfxGetMainWnd()->MessageBox("cannot lock compress buffer!");
  104.       return;
  105.     }               
  106.     
  107.     ((CPhoneApp *) AfxGetApp())->m_OnlyView =  this;  // hook idle thread 
  108.     m_compressWork = FALSE; // no work for background threads 
  109.     m_decompressWork = FALSE;   
  110.     
  111.     m_state.doneBuffer = FALSE;  // nothing to do initially 
  112.     m_state.maxIter = 0L;
  113.     m_state.linearCount = 0; 
  114.     m_state.i = 0L; 
  115.     m_state.lpWaveHdr = (LPWAVEHDR) 0;
  116.     m_state.lpData = (HPSTR) 0;         
  117.     
  118.    m_ListenerStarted = FALSE;
  119. }
  120.  
  121. CPhoneView::~CPhoneView()
  122. {  
  123.       GlobalUnlock(m_hCompress);
  124.       GlobalFree(m_hCompress);
  125.       gsm_destroy(m_hGsm);
  126. }
  127.  
  128. /////////////////////////////////////////////////////////////////////////////
  129. // CPhoneView drawing
  130.  
  131. void CPhoneView::OnDraw(CDC* pDC)
  132. {
  133.     CPhoneDoc* pDoc = GetDocument();
  134.     ASSERT_VALID(pDoc);
  135.  
  136. }
  137.  
  138. /////////////////////////////////////////////////////////////////////////////
  139. // CPhoneView diagnostics
  140.  
  141. #ifdef _DEBUG
  142. void CPhoneView::AssertValid() const
  143. {
  144.     CEditView::AssertValid();
  145. }
  146.  
  147. void CPhoneView::Dump(CDumpContext& dc) const
  148. {
  149.     CEditView::Dump(dc);
  150. }
  151.  
  152. CPhoneDoc* CPhoneView::GetDocument() // non-debug version is inline
  153. {
  154.     ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CPhoneDoc)));
  155.     return (CPhoneDoc*)m_pDocument;
  156. }
  157. #endif //_DEBUG
  158.  
  159. /////////////////////////////////////////////////////////////////////////////
  160. // CPhoneView message handlers
  161.  
  162. void CPhoneView::OnUpdatePhRecord(CCmdUI* pCmdUI)
  163. {                                       
  164.      //
  165.     // Set appropriate states of the UI buttons
  166.     // after the recording button is pressed
  167.        if (!m_recording)
  168.       {
  169.         if(!m_transmitting)
  170.             {
  171.             pCmdUI->Enable(TRUE);
  172.             pCmdUI->SetCheck(FALSE);
  173.             }
  174.         else 
  175.           pCmdUI->Enable(FALSE); 
  176.       }
  177.       else // recording
  178.       {      
  179.         pCmdUI->Enable(TRUE);
  180.         pCmdUI->SetCheck(TRUE);
  181.       }
  182.  
  183. }
  184.  
  185. void CPhoneView::OnUpdatePhSend(CCmdUI* pCmdUI)
  186. {
  187.    // update user interface after the send button
  188.    // is pressed
  189.     if (m_transmitting)      
  190.      {
  191.       pCmdUI->Enable(TRUE);
  192.       pCmdUI->SetCheck(TRUE);
  193.      }
  194.     else // not transmitting
  195.      {
  196.       if (m_recording)     
  197.         {
  198.         pCmdUI->Enable(TRUE);
  199.         pCmdUI->SetCheck(FALSE);
  200.         }
  201.       else
  202.         {
  203.          pCmdUI->Enable(FALSE);
  204.        } 
  205.     }   
  206.  
  207.     
  208. }
  209.  
  210. void CPhoneView::OnPhRecord()
  211. {   
  212.      UINT retval;
  213.     
  214.     // Start the recording process by seizing the WaveIn Device
  215.     // and start sending two priming audio buffer to it
  216.  
  217.     if ((!m_transmitting) && (!m_recording))  // prevent users from repeat presses!
  218.     {
  219.     m_recording = TRUE;   
  220.     m_transmitting = FALSE;
  221.       
  222.    
  223.     PCMWAVEFORMAT format;
  224.     LPWAVEHDR lpWaveHdr;
  225. #ifdef HIGH_FIDELITY       
  226.     format.wf.wFormatTag =  WAVE_FORMAT_PCM;
  227.     format.wf.nChannels = 1;
  228.     format.wf.nSamplesPerSec = 11025;
  229.     format.wf.nAvgBytesPerSec = 22050;
  230.     format.wf.nBlockAlign = 2;
  231.     format.wBitsPerSample = 16; 
  232. #else
  233.     format.wf.wFormatTag =  WAVE_FORMAT_PCM;
  234.     format.wf.nChannels = 1;
  235.     format.wf.nSamplesPerSec = 11025;
  236.     format.wf.nAvgBytesPerSec = 11025;
  237.     format.wf.nBlockAlign = 1;
  238.     format.wBitsPerSample = 8; 
  239. #endif    
  240.     
  241.     // open the device, have message come back to frame window   
  242.     if(::waveInOpen( (LPHWAVEIN) &m_hWaveIn, 0, (LPWAVEFORMAT) &format,  (UINT) m_hWnd,(DWORD) 0,(DWORD) CALLBACK_WINDOW))
  243.     { 
  244.     AfxGetMainWnd()->MessageBox("Cannot open audio input device!");     
  245.     m_recording = FALSE;
  246.     return;
  247.     }
  248.     if(MakeWaveInBuffer(m_hWaveIn, lpWaveHdr, PHONE_WAVEIN_BUFSIZE)== FALSE)
  249.     {                   
  250.     // will announce message internally
  251.     m_recording = FALSE;
  252.     return;               
  253.     }
  254.     if (retval = waveInAddBuffer(m_hWaveIn, lpWaveHdr,  sizeof(WAVEHDR)))
  255.     {
  256.     AfxGetMainWnd()->MessageBox("Cannot add buffer to driver pool!");
  257.     DestroyWaveInBuffer(m_hWaveIn, lpWaveHdr);
  258.     m_recording = FALSE;
  259.     return;
  260.     }       
  261.     // allocate 2nd buffer
  262.     if(MakeWaveInBuffer(m_hWaveIn, lpWaveHdr, PHONE_WAVEIN_BUFSIZE)== FALSE)
  263.     {                   
  264.     // will announce message internally
  265.     m_recording = FALSE;               
  266.     return;
  267.     }
  268.     if (retval = waveInAddBuffer(m_hWaveIn, lpWaveHdr, sizeof(WAVEHDR)))
  269.     {
  270.     AfxGetMainWnd()->MessageBox("Cannot add buffer2 to driver pool!");
  271.     DestroyWaveInBuffer(m_hWaveIn, lpWaveHdr);
  272.     m_recording = FALSE;
  273.     return;                                        
  274.     }
  275.     TRACE("Just sent the first 2 buffers to record!\n");
  276.     if (waveInStart(m_hWaveIn))
  277.     {
  278.     AfxGetMainWnd()->MessageBox("Cannot start recording!");
  279.     m_recording = FALSE;
  280.     return;
  281.     }
  282.     } // of not transmitting
  283. }
  284.  
  285. void CPhoneView::OnPhSend()
  286. {
  287.     // User pressed the Send button.  It is time now to stop the recording
  288.     // thread and start the transmission thread;  BUT remember that the compression
  289.     // thread maynot be finished yet!  We synchronize without
  290.     // locking up by stopping the WaveIn (recording) device, and putting a
  291.     // 'completed' message into the message queue.   
  292.          
  293.     if (m_recording)
  294.     {
  295.     m_transmitting = TRUE;
  296.     m_recording = FALSE;
  297.     // stop recording  
  298.       if( waveInStop(m_hWaveIn))
  299.       {   
  300.        AfxGetMainWnd()->MessageBox("Something funny, cannot stop recording.");
  301.        m_transmitting = FALSE;
  302.        return;
  303.        }
  304.       if( waveInReset(m_hWaveIn))
  305.       {
  306.        AfxGetMainWnd()->MessageBox("Something funny, cannot reset.");
  307.        m_transmitting = FALSE;
  308.        return;
  309.       }   
  310.       // can't process right the way, got to give the MM process
  311.       // some slack
  312.       PostMessage(PHONEMSG_RECORD_DONE);  
  313.       
  314.     }           
  315. }
  316.  
  317. LRESULT CPhoneView::OnCompressDone(WPARAM wParam, LPARAM lParam)
  318. {
  319.  
  320.    //  Start the transmission process now that the background compression
  321.    //  thread has completed.
  322.    
  323.    m_TalkClient.Connect(TCPSOCK, m_ClientAddress,  IGP_PORT, 
  324.      30000, m_hWnd, NULL, 10, m_CompressedBuf, 
  325.        m_CompBufSize  );  // 30000 ms before timer ticks, timer currently not used
  326.    m_transmitting = TRUE; 
  327.    m_CompBufSize = 0; // reset buffer size for next recording! 
  328.    return 0L;
  329. }  
  330.     
  331. /////////////////////////////////////////////////
  332. //
  333. // Multimedia Message Handling
  334. //
  335. // Handle the low level audio 
  336. //
  337.  
  338. LRESULT CPhoneView::OnWaveInClose(WPARAM wParam, LPARAM lParam)
  339. {       
  340. // Not used currently  
  341. //MessageBox("Hi, I'm Here!");
  342. return 0L;
  343. }  
  344.  
  345. LRESULT CPhoneView::OnWaveInData(WPARAM wParam, LPARAM lParam)
  346. { 
  347.     UINT retval;
  348.     LPWAVEHDR lpWaveHdr;      
  349.                      
  350.    // Each time this is called by the system, we have a newly digitized buffer in the
  351.    // WAVE_FORMAT_PCM format, ready for compression and transmission.
  352.    //                                       
  353.    // We prep the buffer for deallocation, put it into an MFC object list for 
  354.    // processing by the compression thread.  If the recording process is still
  355.    // in progress, we supply the WaveIn device with more buffers to avoid choking
  356.    // it.
  357.    
  358.    lpWaveHdr = (LPWAVEHDR) lParam;   
  359.    
  360.   // unprepare immediately
  361.   waveInUnprepareHeader(m_hWaveIn, lpWaveHdr, sizeof(WAVEHDR));
  362.       
  363.   // Store Processed Buffers in our List Here
  364.   m_bufList.Add((DWORD) lParam); 
  365.   TRACE("Got another buffer of %ld bytes, and %s.\n", lpWaveHdr->dwBytesRecorded,
  366.          (lpWaveHdr->dwBufferLength == lpWaveHdr->dwBytesRecorded) ? "sending another":
  367.          "stopping");
  368.          
  369.   // Refill the Driver with at least another buffer!
  370.   // Only if it is not the end of recording. DO NOT send anymore buffer!                    
  371.   // NOTE: a very weak check for recording-in-progress, should be made stronger
  372.   if (lpWaveHdr->dwBytesRecorded == lpWaveHdr->dwBufferLength) // full buffer
  373.   { 
  374.    // note the value of lpWaveHdr will be changed by the next call
  375.     if(MakeWaveInBuffer(m_hWaveIn, lpWaveHdr, PHONE_WAVEIN_BUFSIZE)== FALSE)
  376.     {                   
  377.     return 0L;             
  378.     }
  379.     if (retval = waveInAddBuffer(m_hWaveIn, lpWaveHdr,  sizeof(WAVEHDR)))
  380.     {
  381.     AfxGetMainWnd()->MessageBox("Recycling: Cannot add buffer to driver pool!");
  382.     DestroyWaveInBuffer(m_hWaveIn, lpWaveHdr);
  383.     m_recording = FALSE;
  384.     return 0L;
  385.     }       
  386.    }                                             
  387.    
  388.    // tell background thread to start compressing if not already set
  389.    if (m_compressWork == FALSE) 
  390.    {
  391.      m_compressWork = TRUE;
  392.      m_state.doneBuffer = FALSE;
  393.    }
  394.    
  395. return 0L;
  396. }
  397.  
  398. LRESULT CPhoneView::OnWaveInOpen(WPARAM wParam, LPARAM lParam)
  399. {   
  400. // Not used currently          
  401. //MessageBox("Hi, I'm Here!");
  402. return 0L;
  403. }                            
  404.  
  405. LRESULT CPhoneView::OnWaveOutDone(WPARAM wParam, LPARAM lParam)
  406. {   
  407.   LPWAVEHDR lpWaveHdr;   
  408.   LPWAVEINST lpWaveInst;
  409.   BOOL LastBlock;
  410.  
  411.    // Each time this is called by the system, we have another audio buffer
  412.    // finished playing.  It is time to de-allocate the resources used by
  413.    // the audio buffer at this point.
  414.    //
  415.    // For the last audio block, we shut off the WaveOut device and reset
  416.    // playback statistics.
  417.    
  418.   // clean up the returned block
  419.   lpWaveHdr = (LPWAVEHDR) lParam;  
  420.   
  421.   // close up everything if it is the last block
  422.   lpWaveInst = (LPWAVEINST) lpWaveHdr->dwUser;
  423.   LastBlock = lpWaveInst->LastBlock;  
  424.   
  425.   DestroyWaveOutBuffer(m_hWaveOut, lpWaveHdr); // clean the block
  426.   
  427.   if ( LastBlock == TRUE)
  428.    {
  429.    waveOutClose(m_hWaveOut);
  430.    m_hWaveOut = 0;   
  431.     // set up compression buffer
  432.     m_CompBufSize = 0L;   
  433.    }
  434.    
  435.  
  436.   return 0L;
  437. }
  438.  
  439. LRESULT CPhoneView::OnRecordDone(WPARAM wParam, LPARAM lParam)
  440. {    
  441.   // Message indicating that recording has completed.  We simply
  442.   // turn off the WaveIn device at this point. Note that we cannot
  443.   // turn off the device any earlier because there may have been some
  444.   // more buffers to clear.  Remember that we're simulating a multi-threaded
  445.   // behaviour with segmented sequentially executed code!
  446.     
  447.     waveInClose(m_hWaveIn);
  448.     m_hWaveIn = 0;    // free up the device for playing
  449.        
  450.            
  451.     TRACE("Closed input device.\n");
  452.                               
  453.   // We cannot do anymore here.  If we open output device or start decompression,
  454.   // lockup WILL occur.  Instead, we delegate the responsibility to the background
  455.   // threads processing in the idle loop.
  456.                                 
  457.  return 0L;
  458. }  
  459. ////////////////////////////////////////////////////////////////////
  460. // Audio Buffer Management Routines                                 
  461. //
  462. // These are the 'standard' low level audio buffers allocation,
  463. // priming, de-priming, and de-allocation routines.  Extremely tedious 
  464. // and non-interesting, note also that error handling is very poor 
  465. // currently:  we just pop up application model dialog boxes.
  466. //
  467. BOOL CPhoneView::MakeWaveInBuffer(HWAVEIN hWaveIn, LPWAVEHDR &lpWaveHdr, DWORD dwBufSize)  // Create a New buffer
  468. {   
  469.     HGLOBAL  hData, hWaveHdr, hWaveInst;
  470.     HPSTR lpData;
  471.     LPWAVEINST lpWaveInst;
  472.  
  473.     // get the first buffer             
  474.     hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, dwBufSize);
  475.     if (!hData)
  476.     {
  477.       AfxGetMainWnd()->MessageBox("cannot allocate buffer!");
  478.       return FALSE;
  479.     }             
  480.     if ((lpData = (HPSTR) GlobalLock(hData))== NULL)  
  481.      {
  482.        AfxGetMainWnd()->MessageBox("cannot lock memory for buffer!");
  483.        GlobalFree(hData);
  484.        return FALSE;
  485.      }                
  486.     
  487.         
  488.     /* Allocate a waveform data header. The WAVEHDR must be 
  489.      * globally allocated and locked.
  490.      */
  491.     hWaveHdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
  492.                            (DWORD) sizeof(WAVEHDR));
  493.     if (!hWaveHdr)
  494.     {
  495.         GlobalUnlock( hData );
  496.         GlobalFree( hData );
  497.         MessageBox( "Not enough memory for header.",
  498.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  499.         return FALSE;
  500.     }
  501.     lpWaveHdr = (LPWAVEHDR) GlobalLock(hWaveHdr);
  502.     if (!lpWaveHdr)
  503.     {
  504.         GlobalUnlock( hData );
  505.         GlobalFree( hData );
  506.         GlobalFree( hWaveHdr );
  507.         AfxGetMainWnd()->MessageBox( "Failed to lock memory for header.",
  508.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  509.         return FALSE;
  510.     }
  511.  
  512.     /* Allocate and set up instance data for waveform data block.
  513.      * This information is needed by the routine that frees the
  514.      * data block after it has been played.
  515.      */
  516.     hWaveInst = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
  517.                             (DWORD) sizeof(WAVEINST));
  518.     if (!hWaveInst)
  519.     {
  520.         GlobalUnlock( hData );
  521.         GlobalFree( hData );
  522.         GlobalUnlock( hWaveHdr );
  523.         GlobalFree( hWaveHdr );
  524.         AfxGetMainWnd()->MessageBox( "Not enough memory for instance data.",
  525.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  526.         return FALSE;
  527.     }
  528.     lpWaveInst = (LPWAVEINST) GlobalLock(hWaveInst);
  529.     if (!lpWaveInst)
  530.     {
  531.         GlobalUnlock( hData );
  532.         GlobalFree( hData );
  533.         GlobalUnlock( hWaveHdr );
  534.         GlobalFree( hWaveHdr );
  535.         GlobalFree( hWaveInst );
  536.         AfxGetMainWnd()->MessageBox("Failed to lock memory for instance data.",
  537.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  538.         return FALSE;
  539.     }
  540.     lpWaveInst->hWaveInst = hWaveInst;
  541.     lpWaveInst->hWaveHdr = hWaveHdr;
  542.     lpWaveInst->hWaveData = hData;
  543.         
  544.     /* Set up WAVEHDR structure and prepare it to be written to wave device.
  545.      */
  546.     lpWaveHdr->lpData = lpData;
  547.     lpWaveHdr->dwBufferLength = dwBufSize;
  548.     lpWaveHdr->dwBytesRecorded = 0L;    
  549.     lpWaveHdr->dwFlags = 0L;
  550.     lpWaveHdr->dwLoops = 0L;
  551.     lpWaveHdr->dwUser = (DWORD) lpWaveInst;
  552.     if(waveInPrepareHeader(hWaveIn, lpWaveHdr, sizeof(WAVEHDR)))
  553.     {
  554.         GlobalUnlock( hData );
  555.         GlobalFree( hData );
  556.         GlobalUnlock( hWaveHdr );
  557.         GlobalFree( hWaveHdr );
  558.         GlobalUnlock( hWaveInst );
  559.         GlobalFree( hWaveInst );
  560.         AfxGetMainWnd()->MessageBox( "Unable to prepare wave header.",
  561.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  562.         return FALSE;           
  563.      }               
  564.  return TRUE;    
  565. }
  566. BOOL CPhoneView::MakeWaveOutBuffer(HWAVEIN hWaveIn, HWAVEOUT hWaveOut, LPWAVEHDR &lpWaveHdr, DWORD dwBufSize)
  567. { 
  568.     /* Set up WAVEHDR structure and prepare it to be written to wave device.
  569.      
  570.     lpWaveHdr->dwBufferLength = lpWaveHdr->dwBytesRecorded;
  571.     lpWaveHdr->dwBytesRecorded = 0L;    
  572.     lpWaveHdr->dwFlags = 0L;
  573.     lpWaveHdr->dwLoops = 0L;
  574.  
  575.   // no need for hWaveIn since the header is unprepared before storage
  576.   if (waveOutPrepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR)))
  577.   {
  578.   AfxGetMainWnd()->MessageBox("Cannot transform inbuf to outbuf?");
  579.   return FALSE;
  580.   } 
  581.   return TRUE;   
  582.   */
  583.   
  584.     HGLOBAL  hData, hWaveHdr, hWaveInst;
  585.     HPSTR lpData;
  586.     LPWAVEINST lpWaveInst;
  587.  
  588.     // get the first buffer             
  589.     hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, dwBufSize);
  590.     if (!hData)
  591.     {
  592.       AfxGetMainWnd()->MessageBox("cannot allocate buffer!");
  593.       return FALSE;
  594.     }             
  595.     if ((lpData = (HPSTR) GlobalLock(hData))== NULL)  
  596.      {
  597.        AfxGetMainWnd()->MessageBox("cannot lock memory for buffer!");
  598.        GlobalFree(hData);
  599.        return FALSE;
  600.      }                
  601.     
  602.         
  603.     /* Allocate a waveform data header. The WAVEHDR must be 
  604.      * globally allocated and locked.
  605.      */
  606.     hWaveHdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
  607.                            (DWORD) sizeof(WAVEHDR));
  608.     if (!hWaveHdr)
  609.     {
  610.         GlobalUnlock( hData );
  611.         GlobalFree( hData );
  612.         MessageBox( "Not enough memory for header.",
  613.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  614.         return FALSE;
  615.     }
  616.     lpWaveHdr = (LPWAVEHDR) GlobalLock(hWaveHdr);
  617.     if (!lpWaveHdr)
  618.     {
  619.         GlobalUnlock( hData );
  620.         GlobalFree( hData );
  621.         GlobalFree( hWaveHdr );
  622.         AfxGetMainWnd()->MessageBox( "Failed to lock memory for header.",
  623.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  624.         return FALSE;
  625.     }
  626.  
  627.     /* Allocate and set up instance data for waveform data block.
  628.      * This information is needed by the routine that frees the
  629.      * data block after it has been played.
  630.      */
  631.     hWaveInst = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
  632.                             (DWORD) sizeof(WAVEINST));
  633.     if (!hWaveInst)
  634.     {
  635.         GlobalUnlock( hData );
  636.         GlobalFree( hData );
  637.         GlobalUnlock( hWaveHdr );
  638.         GlobalFree( hWaveHdr );
  639.         AfxGetMainWnd()->MessageBox( "Not enough memory for instance data.",
  640.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  641.         return FALSE;
  642.     }
  643.     lpWaveInst = (LPWAVEINST) GlobalLock(hWaveInst);
  644.     if (!lpWaveInst)
  645.     {
  646.         GlobalUnlock( hData );
  647.         GlobalFree( hData );
  648.         GlobalUnlock( hWaveHdr );
  649.         GlobalFree( hWaveHdr );
  650.         GlobalFree( hWaveInst );
  651.         AfxGetMainWnd()->MessageBox("Failed to lock memory for instance data.",
  652.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  653.         return FALSE;
  654.     }
  655.     lpWaveInst->hWaveInst = hWaveInst;
  656.     lpWaveInst->hWaveHdr = hWaveHdr;
  657.     lpWaveInst->hWaveData = hData;
  658.     lpWaveInst->LastBlock = FALSE;  // most are not last block
  659.         
  660.     /* Set up WAVEHDR structure and prepare it to be written to wave device.
  661.      */
  662.     lpWaveHdr->lpData = lpData;
  663.     lpWaveHdr->dwBufferLength = dwBufSize;
  664.     lpWaveHdr->dwBytesRecorded = 0L;    
  665.     lpWaveHdr->dwFlags = 0L;
  666.     lpWaveHdr->dwLoops = 0L;
  667.     lpWaveHdr->dwUser = (DWORD) lpWaveInst;
  668.     if(waveOutPrepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR)))
  669.     {
  670.         GlobalUnlock( hData );
  671.         GlobalFree( hData );
  672.         GlobalUnlock( hWaveHdr );
  673.         GlobalFree( hWaveHdr );
  674.         GlobalUnlock( hWaveInst );
  675.         GlobalFree( hWaveInst );
  676.         AfxGetMainWnd()->MessageBox( "Unable to prepare wave out header.",
  677.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  678.         return FALSE;           
  679.      }               
  680.  return TRUE;    
  681.  
  682. }
  683.  
  684. BOOL CPhoneView::DestroyWaveInBuffer(HWAVEIN hWaveIn, LPWAVEHDR lpWaveHdr)
  685. {  
  686.    LPWAVEINST lpWaveInst;
  687.    if (hWaveIn)  // don't bother if not necessary
  688.      waveInUnprepareHeader(hWaveIn, lpWaveHdr, sizeof(WAVEHDR) );
  689.    lpWaveInst = (LPWAVEINST) lpWaveHdr->dwUser;   
  690.    GlobalUnlock( lpWaveInst->hWaveData );
  691.    GlobalFree( lpWaveInst->hWaveData );
  692.    GlobalUnlock( lpWaveInst->hWaveHdr );
  693.    GlobalFree( lpWaveInst->hWaveHdr );
  694.    GlobalUnlock( lpWaveInst->hWaveInst );
  695.    GlobalFree( lpWaveInst->hWaveInst );   
  696.    return (TRUE);
  697.  
  698. }
  699.  
  700. BOOL CPhoneView::DestroyWaveOutBuffer(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveHdr)
  701. {  
  702.    LPWAVEINST lpWaveInst;
  703.    
  704.    waveOutUnprepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR) );
  705.    lpWaveInst = (LPWAVEINST) lpWaveHdr->dwUser;   
  706.    GlobalUnlock( lpWaveInst->hWaveData );
  707.    GlobalFree( lpWaveInst->hWaveData );
  708.    GlobalUnlock( lpWaveInst->hWaveHdr );
  709.    GlobalFree( lpWaveInst->hWaveHdr );
  710.    GlobalUnlock( lpWaveInst->hWaveInst );
  711.    GlobalFree( lpWaveInst->hWaveInst );   
  712.    return (TRUE);
  713.  
  714. }
  715.  
  716. ///////////////////////////////////////////////////////////////////////
  717. // Compression and Expansion routines    
  718. //
  719. // These are helper routines for the GSM compression and decompression.
  720. //
  721. LRESULT CPhoneView::CompressABuffer(HPSTR lpData, DWORD lsize)
  722. {         
  723.  ULONG maxIter;   
  724.  //
  725.  // Compress the buffer pointed to by lpData of size lsize
  726.  // and store data into the internal m_CompressedBuf[]
  727.  //
  728.  maxIter = lsize / GSM_FRAME_SIZE;  // do up to last GSM_FRAME_SIZE block
  729. #ifdef HIGH_FIDELITY
  730.  maxIter /= 2;            // 16 bit handling
  731. #endif 
  732.  ULONG linearCount = 0L;
  733.  for (ULONG i=0; i<maxIter; i++)
  734.  {
  735.   for (UINT j=0; j<GSM_FRAME_SIZE; j++)
  736.   { 
  737.   short c;  
  738. #ifdef HIGH_FIDELITY
  739.    c =  *((short far *)(lpData +linearCount));  
  740. //  16 bit samples are SIGNED!!  so we don't need:   c ^= 0x8000;  
  741.    m_sample[j] = c;
  742.    linearCount += 2;
  743. #else  
  744.   c = ((short) (lpData[linearCount++] ^ 128));
  745.   m_sample[j] = (c << 8) + 8; 
  746. #endif  
  747.   }                                    
  748.   gsm_encode(m_hGsm, m_sample, m_GsmBuf); 
  749.   AddOut((LPSTR) m_GsmBuf, sizeof(m_GsmBuf)); 
  750.  } 
  751.  
  752.  return 0L;
  753. }
  754.  
  755. LRESULT CPhoneView::CompressPartialBuffer(LPTSTATE state)
  756. {
  757.   // Yuk!  This is part of a 'flattened' multi-loop used by the background thread
  758.   // (in the idle loop) to perform a 'partial buffer compression'
  759.   // each time an idle time slice is available.  All done in the name
  760.   // of a 'better behaved' Windows application.  It will perform one
  761.   // GSM frame worth of compression and then return control back to
  762.   // the message pump as long as work is still available.
  763.   //
  764.   if (state->maxIter == 0)
  765.   {
  766.    state->maxIter = state->lpWaveHdr->dwBytesRecorded / GSM_FRAME_SIZE;
  767. #ifdef HIGH_FIDELITY
  768.  state->maxIter /= 2;            // 16 bit handling
  769. #endif  
  770.    state->linearCount = 0L;
  771.    state->i = 0L;          
  772.    state->doneBuffer = FALSE;  
  773. TRACE("Did One Buffer with comp buf size at %lu.\n", m_CompBufSize);   
  774.   }
  775.   
  776.   if (state->i < state->maxIter)
  777.   {    
  778.   // do a GSM FRAME
  779.   HPSTR lpData;  
  780.   lpData = (HPSTR) state->lpWaveHdr->lpData;
  781.   for (UINT j=0; j<GSM_FRAME_SIZE; j++)
  782.   { 
  783.   short c;  
  784. #ifdef HIGH_FIDELITY
  785.    c =  *((short far *)(lpData + state->linearCount));  
  786. //  16 bit samples are SIGNED!!  so we don't need:   c ^= 0x8000;  
  787.    m_sample[j] = c;
  788.    state->linearCount += 2;
  789. #else  
  790.   c = ((short) (lpData[state->linearCount++] ^ 128));
  791.  
  792.  // lpData[linearCount] ^= 128;  // switch unsigned to signed
  793.  // m_sample[j] = U2S(lpData[linearCount]);         
  794.   m_sample[j] = (c << 8) + 8; 
  795. #endif  
  796.   }   // of for                                 
  797.   gsm_encode(m_hGsm, m_sample, m_GsmBuf); 
  798.   AddOut((LPSTR) m_GsmBuf, sizeof(m_GsmBuf)); 
  799.   
  800.   
  801.   state->i += 1;
  802.   return 0L;
  803.   }     // of if state->i < state->maxIter
  804.  else
  805.   {                         
  806.    state->maxIter = 0;
  807.    state->doneBuffer = TRUE;   
  808.    DestroyWaveInBuffer(m_hWaveIn, state->lpWaveHdr);
  809.  
  810.    return 1L; // completed
  811.   }
  812. }
  813.  
  814. void CPhoneView::AddOut(LPSTR sbuf, UINT lsize)
  815. { 
  816.   // Data Mover Helper, make the main code somewhat less messy
  817.   //
  818.   // add an GSM frame or buffer to the CompressedBuf
  819.   for (UINT j=0; j<lsize; j++)
  820.   {
  821.     m_CompressedBuf[m_CompBufSize++] = sbuf[j];
  822.   }
  823. }                       
  824.  
  825. LRESULT CPhoneView::ExpandWaveOut(HGLOBAL hMem, HPSTR CompressedBuf, ULONG CompBufSize)
  826. {
  827.  UINT retval;        
  828.  PCMWAVEFORMAT format;
  829.  
  830.   // The Listener has spawned a server and the server has received all the compressed
  831.   // audiodata.  We now prime and open the WaveOut device for playback, prep an audio
  832.   // buffer, and start the background de-compression thread on its merry way.
  833.   //       
  834. // Open Audio Output Device
  835. #ifdef HIGH_FI_OUT       
  836.     format.wf.wFormatTag =  WAVE_FORMAT_PCM;
  837.     format.wf.nChannels = 1;
  838.     format.wf.nSamplesPerSec = 11025;
  839.     format.wf.nAvgBytesPerSec = 22050;
  840.     format.wf.nBlockAlign = 2;
  841.     format.wBitsPerSample = 16; 
  842. #else 
  843.     format.wf.wFormatTag =  WAVE_FORMAT_PCM;
  844.     format.wf.nChannels = 1;
  845.     format.wf.nSamplesPerSec = 11025;
  846.     format.wf.nAvgBytesPerSec = 11025;
  847.     format.wf.nBlockAlign = 1;
  848.     format.wBitsPerSample = 8; 
  849. #endif /*   don't implement yet... */
  850.     
  851.     // Try and open audio output device.  If failure, should try again later
  852.     // just in case it is currently recording.    
  853.     if(retval = waveOutOpen( (LPHWAVEOUT) &m_hWaveOut, 0, (LPWAVEFORMAT) &format,  
  854.     (UINT) m_hWnd,(DWORD) 0,(DWORD) CALLBACK_WINDOW))
  855.     { 
  856.     AfxGetMainWnd()->MessageBox("Cannot open audio output device!");     
  857.     m_transmitting = FALSE;
  858.     return 0L;
  859.     } 
  860.     // else
  861.     // {
  862.     //   SHOULD HANDLE DELAYED-RETRY HERE ON A TIMER IN THE FUTURE
  863.     // }
  864.             
  865.  TRACE("Begin expansion...\n");
  866.  if(MakeWaveOutBuffer(m_hWaveIn, m_hWaveOut, m_dstate.lpWaveHdr, (DWORD)PHONE_WAVEOUT_BUFSIZE)== FALSE)  
  867.   {
  868.   AfxGetMainWnd()->MessageBox("Cannot allocate waveout buffers.");
  869.   return 0L;
  870.   }                     
  871.   
  872.  // set up background thread states and let idle-processing handle it       
  873.  m_dstate.lpData = m_dstate.lpWaveHdr->lpData;
  874.  
  875.  m_dstate.linear = 0;  // counter for Play Buffer fill   
  876.  m_dstate.b = 0;       // counter for GSM FRAME fill
  877.  m_dstate.CompressedBuf = CompressedBuf;
  878.  m_dstate.CompBufSize = CompBufSize;
  879.  
  880.  m_dstate.i = 0;
  881.  m_decompressWork = TRUE;
  882.                                 
  883.  m_hspeechBuffer = hMem; // used for memory deallocation later
  884.  
  885.     return 0L;
  886. }  
  887.  
  888. LRESULT CPhoneView::PlayWaveInBuffer(LPWAVEHDR lpWaveHdr)
  889. {                                                   
  890.  LPWAVEINST lpWaveInst;
  891.  lpWaveInst = (LPWAVEINST) lpWaveHdr->dwUser;
  892.  lpWaveInst->LastBlock = FALSE;
  893.  UINT retval;                   
  894.  //
  895.  // routine used in testing only
  896.     lpWaveHdr->dwBufferLength = lpWaveHdr->dwBytesRecorded;
  897.     lpWaveHdr->dwBytesRecorded = 0L;    
  898.     lpWaveHdr->dwFlags = 0L;
  899.     lpWaveHdr->dwLoops = 0L;
  900.  
  901.     if(waveOutPrepareHeader(m_hWaveOut, lpWaveHdr, sizeof(WAVEHDR)))
  902.     {
  903.          DestroyWaveOutBuffer(m_hWaveOut, lpWaveHdr);
  904.         AfxGetMainWnd()->MessageBox( "Unable to prepare wave out header.",
  905.                    NULL, MB_OK | MB_ICONEXCLAMATION);
  906.         return 1L;           
  907.      }               
  908.         if (retval = waveOutWrite(m_hWaveOut, lpWaveHdr, sizeof(WAVEHDR)))
  909.          {
  910.           AfxGetMainWnd()->MessageBox("Cannot write buffer to output device!");
  911.           DestroyWaveOutBuffer(m_hWaveOut, lpWaveHdr);
  912.           m_transmitting = FALSE;
  913.           return 1L;                                        
  914.           }                    
  915.                                                   
  916.   return 0L;                                                  
  917.                                                   
  918. }  
  919.  
  920. BOOL CPhoneView::DoIdleProcessing(void)
  921. {     
  922.    UINT retval;          
  923.    //  
  924.    // This function is called everything the system is Idle.  We use this
  925.    // chance to perform our background compression and de-compression.
  926.    //
  927.    // Both of these 'background threads' are multi-nested-loops which are
  928.    // 'flattened' in order to perform a very small unit of work on every
  929.    // idle opportunity.  This keeps the application well behaving under
  930.    // Windows.
  931.    //
  932.    UINT numBuf = m_bufList.GetSize();   
  933.  
  934.  if (m_ListenerStarted == FALSE)
  935.  {    
  936.     // start up listener if not started
  937.     m_TalkListener.StartListener(NULL, IGP_PORT, (LPWSADDRESS) &m_ListenerAddress, m_hWnd, NULL, this);
  938.     m_ListenerStarted = TRUE; 
  939.     m_ClientAddress = m_TalkListener.MyAddress();
  940.     GetEditCtrl().SetSel(-1,-1);
  941.     GetEditCtrl().ReplaceSel((LPSTR) "IGP Listener started\r\n");
  942.  }
  943.                                         
  944.  // THE COMPRESSION THREAD                                        
  945.  // We have very little time, really
  946.  // do just 1 GSM frame
  947.  if (m_compressWork == TRUE)
  948.  { 
  949.  
  950.  
  951.     if (m_state.doneBuffer == TRUE)
  952.    { 
  953.    
  954.      m_state.doneBuffer = FALSE;
  955.  
  956.      // can't check for 1 left, since recording  maybe in progress
  957.      if (( m_recording == FALSE) && (numBuf <=1))
  958.      {                     
  959.         LPWAVEHDR lpWaveHdr = (LPWAVEHDR) m_bufList[0];
  960.         DestroyWaveInBuffer(m_hWaveIn,lpWaveHdr);
  961.         m_bufList.RemoveAll();
  962. TRACE("Pull last buffer.\n");
  963.          m_transmitting = TRUE;             
  964.          m_compressWork = FALSE;   
  965.          
  966.          // reset here, otherwise face major re-entrancy problems
  967.          m_state.doneBuffer = FALSE;  // nothing to do initially 
  968.         m_state.maxIter = 0L;
  969.         m_state.linearCount = 0; 
  970.         m_state.i = 0L; 
  971.         m_state.lpWaveHdr = (LPWAVEHDR) 0;
  972.         m_state.lpData = (HPSTR) 0;         
  973.  
  974.         // signifies completion of background compress thread         
  975.          PostMessage(PHONEMSG_COMPRESS_DONE);  
  976.          return 0;
  977.      }
  978.      else
  979.      {
  980.          if (numBuf >= 1)
  981.          {                  
  982. TRACE("Pull a buffer because DoneFlag!\n");         
  983.          // load up new buffer
  984.          m_state.lpWaveHdr = (LPWAVEHDR) m_bufList[0];   
  985.          m_state.lpData = (HPSTR) m_state.lpWaveHdr->lpData;
  986.          m_bufList.RemoveAt(0);
  987.          }
  988.       } // of else    
  989.     } // of Done Buffer == TRUE 
  990.     else // first time only
  991.     {
  992.       if ((numBuf >=1) && (m_state.lpWaveHdr == (LPWAVEHDR) 0))
  993.       { 
  994. TRACE("First time only pull buffer!\n");       
  995.         // load up new buffer
  996.          m_state.lpWaveHdr = (LPWAVEHDR) m_bufList[0];   
  997.          m_state.lpData = (HPSTR) m_state.lpWaveHdr->lpData;
  998.          m_bufList.RemoveAt(0);
  999.  
  1000.       }
  1001.     }                           
  1002.     if (((m_recording == TRUE) && (numBuf >= 1))
  1003.     || ((m_recording == FALSE)/* && (numBuf <=1)*/))  // during recording, numbuf may = 0
  1004.       CompressPartialBuffer((LPTSTATE) &m_state);    
  1005.     return 1;    
  1006.   } // of m_compressWork
  1007.  
  1008.  // THE DECOMPRESSION THREAD                                        
  1009.  // We have very little time, do just 1 GSM frame.
  1010.  // Everytime we finish decompression a complete audio buffer,
  1011.  // we'll send it to WaveOut for playback from here.
  1012.  
  1013.  if (m_decompressWork == TRUE)
  1014.    {
  1015.       //for( UINT i=0; i<CompBufSize; i++)
  1016.       //if (m_dstate.i < m_dstate.CompBufSize)
  1017.       for (UINT i=0; (i<sizeof(m_GsmBuf)) && (m_dstate.i < m_dstate.CompBufSize);
  1018.           i++)
  1019.       {
  1020.         m_GsmBuf[i] = m_dstate.CompressedBuf[m_dstate.i];
  1021.         m_dstate.i++;
  1022.       }   
  1023.       
  1024.           gsm_decode(m_hGsm, m_GsmBuf, m_sample);  // no error check here for simplicity
  1025.               
  1026.           for (UINT aa =0; aa <  GSM_FRAME_SIZE; aa++)   {
  1027. #ifdef HIGH_FI_OUT                                     
  1028.            // 16 bit samples are signed automagically
  1029.            *((short far *) (m_dstate.lpData + m_dstate.linear)) = m_sample[aa];
  1030.            m_dstate.linear += 2;
  1031. #else   
  1032.           // 8 bit samples need are unsigned and need changes
  1033.           char c = (char) ((m_sample[aa]) >> 8) ;     
  1034. //        unsigned char c = S2U(m_sample[aa]); 
  1035.           c ^= 128;  // put it back to unsigned
  1036.           m_dstate.lpData[m_dstate.linear++] = c;
  1037. #endif        
  1038.            }  // of for aa     
  1039.            
  1040.        if (m_dstate.i < m_dstate.CompBufSize)
  1041.         {    
  1042.  
  1043.          if (m_dstate.linear == PHONE_WAVEOUT_BUFSIZE)  
  1044.          {                        
  1045.            if (m_dstate.i == m_dstate.CompBufSize - 1) // special case of alignment
  1046.            {
  1047.             // mark last block
  1048.             m_dstate.lpWaveInst = (LPWAVEINST) m_dstate.lpWaveHdr->dwUser;
  1049.             m_dstate.lpWaveInst->LastBlock = TRUE;                              
  1050.            }
  1051.            m_dstate.linear = 0L; 
  1052.            
  1053.            TRACE("Printing 32 output buffer values:\n");
  1054.            /* for (UINT j=0; j<32; j++) 
  1055.             {
  1056.              TRACE ("C:%x ", (unsigned)lpData[j]); }
  1057.              TRACE("\n");
  1058.             */
  1059.            // send the data to play   
  1060.            if (retval = waveOutWrite(m_hWaveOut, m_dstate.lpWaveHdr, sizeof(WAVEHDR)))
  1061.            {
  1062.              AfxGetMainWnd()->MessageBox("Cannot write buffer to output device!");
  1063.              DestroyWaveOutBuffer(m_hWaveOut, m_dstate.lpWaveHdr);
  1064.              return 0L;                                        
  1065.            }                    
  1066.            TRACE("Decompressed and sent a buffer of size %ld to output.\n",
  1067.                m_dstate.lpWaveHdr->dwBufferLength); 
  1068.           // sent one, make another buffer ready                                                      
  1069.            if(MakeWaveOutBuffer(m_hWaveIn, m_hWaveOut, m_dstate.lpWaveHdr, 
  1070.             (DWORD)PHONE_WAVEOUT_BUFSIZE)== FALSE)  
  1071.               {
  1072.                   AfxGetMainWnd()->MessageBox("Cannot allocate waveout buffers.");
  1073.                   return 0L;
  1074.               }           
  1075.            m_dstate.lpData = m_dstate.lpWaveHdr->lpData;  // vital -> forgot this in a bug?
  1076.          }  // of linear == PHONEWAVEOUT SIZE  
  1077.  
  1078.       return 1;
  1079.      } // of (if  i < compbufSize)
  1080.      else
  1081.      {  // i >= compbufSize
  1082.        if (m_dstate.linear != 0L)
  1083.         {
  1084.           // handle final block
  1085.           m_dstate.lpWaveInst = (LPWAVEINST) m_dstate.lpWaveHdr->dwUser;
  1086.           m_dstate.lpWaveInst->LastBlock = TRUE;                              
  1087.           m_dstate.lpWaveHdr->dwBufferLength = m_dstate.linear;
  1088.           if (retval = waveOutWrite(m_hWaveOut, m_dstate.lpWaveHdr, sizeof(WAVEHDR)))
  1089.           {
  1090.              AfxGetMainWnd()->MessageBox("Cannot write buffer to output device!");
  1091.              DestroyWaveOutBuffer(m_hWaveOut, m_dstate.lpWaveHdr);
  1092.              m_decompressWork = FALSE;
  1093.              m_transmitting = FALSE;
  1094.              return 0L ;                                        
  1095.            }                        
  1096.           m_decompressWork = FALSE;
  1097.           
  1098.           // free the speech buffer now
  1099.            if (m_hspeechBuffer)
  1100.                {
  1101.                    GlobalUnlock(m_hspeechBuffer);
  1102.                    GlobalFree(m_hspeechBuffer);
  1103.                }                                 
  1104.           TRACE("Printing 32 output buffer values:\n");
  1105.           for (UINT j=0; j<32; j++) 
  1106.            {
  1107.             TRACE ("C:%x ", (unsigned)m_dstate.lpData[j]); 
  1108.            }
  1109.             TRACE("\n");
  1110.  
  1111.              TRACE("Decompressed and sent LAST buffer of size %ld to output.\n",
  1112.                m_dstate.lpWaveHdr->dwBufferLength); 
  1113.                 
  1114.          } // of linear !=0  
  1115.       } // of else  i>=bufsize
  1116.   } // of decompressWork == TRUE      
  1117.   
  1118. return 0;
  1119. }
  1120.  
  1121. ////////////////////////////////////////////////////////////////////////
  1122. // Misc routines
  1123. //
  1124.  
  1125. void CPhoneView::OnFileOpen()
  1126. {
  1127.     // Pop a dialog box and allow user to enter the IP address to talk to here 
  1128.     CDlgHostID abc;                       
  1129.  
  1130.        abc.m_InetAddress = (ULONG) m_ClientAddress;
  1131.  
  1132.     if (abc.DoModal() == IDOK)    
  1133.       m_ClientAddress = (WSADDRESS) WSNToHL(abc.m_InetAddress);
  1134.     
  1135. }                            
  1136.  
  1137. LRESULT CPhoneView::OnClientNotify(WPARAM wParam, LPARAM lParam)
  1138. {                  
  1139.  // clearing house function for status, error messages and connection troubles 
  1140.  //
  1141.  UINT event, errcode;
  1142.  char tps[90];   // Pardon that magic number!:)
  1143.  event = WSEVENT(lParam);
  1144.  errcode = WSERROR(lParam); 
  1145.  switch(event)
  1146.  {
  1147.   case WSCONNECTED: 
  1148.    if (errcode == 0)
  1149.     wsprintf(tps, "Client: Connected to Remote (%x).\r\n", errcode);
  1150.    else   
  1151.    {
  1152.     wsprintf(tps, "Client: Failed to connect to remote (%x).\r\n", errcode);
  1153.     m_recording = FALSE;
  1154.     m_transmitting = FALSE;
  1155. //    m_CompBufSize = 0;
  1156.    }
  1157.    break;   
  1158.   case WSTALKBACK:
  1159.    wsprintf(tps, "Client: Connect timer expired (%x).\r\n", errcode);
  1160.    break; 
  1161.   case WSDISCONNECTED:
  1162.    wsprintf(tps, "Client: Disconnected from remote (%x).\r\n", errcode); 
  1163.    m_hWaveIn = 0;
  1164.    m_recording=FALSE;
  1165.    m_transmitting = FALSE;
  1166.    break;   
  1167.   case WSTALKLISCONNECT:
  1168.    wsprintf(tps, "Listener: Detected remote client connection (%x).\r\n", errcode);
  1169.    break;
  1170.   case WSTALKLISFAILED:
  1171.    wsprintf(tps, "Listener: Cannot start server, low memory (%x).\r\n", errcode);
  1172.    break;  
  1173.   case WSCHILDCLOSED:
  1174.    wsprintf(tps, "Server: Remote disconnected, server freed.(%x).\r\n", errcode);
  1175.    break;  
  1176.   case WSTALKNEWCHILD:
  1177.    wsprintf(tps, "Server: A new server is started (%x).\r\n", errcode);
  1178.    break;
  1179.   case WSTALKFAILED:
  1180.    wsprintf(tps, "Client: Problem in protocol negotiation (%x).\r\n", errcode);
  1181.    break;  
  1182.   default:
  1183.     wsprintf(tps, "Client: Received event = %x,  Error = %x\r\n", event, errcode);
  1184.     break;
  1185.  }  
  1186.     GetEditCtrl().SetSel(-1,-1);
  1187.     GetEditCtrl().ReplaceSel((LPSTR) tps);
  1188.  
  1189.  
  1190.  TRACE("WINDOW RECEIVED Code Event = %x,  Error = %x\n", event, errcode); 
  1191.  
  1192. return 0L;
  1193. }            
  1194.  
  1195.